/**
 * 文件级注释：
 * 分账管理前端服务封装，统一通过 axios 封装层调用后端接口。
 * 规则：仅当返回值 `code === 0` 时认为接口调用成功。
 * 环境：仅在 H5 项目中使用与维护。
 */

import http from '../api/http'
import type { ApiResult, PageResult } from './types'

/**
 * 类级注释：分账协议请求与响应相关类型
 */
export interface DividedAgreementRequest {
  /** 分账协议ID（编辑/删除场景） */
  Id?: string
  /** 协议名称 */
  AgreementName?: string
  /** 商户ID */
  MerchantId?: string
  /** 分账周期（天数或枚举）；视后端定义 */
  DividedCycle?: number
  /** 生效开始时间（ISO 字符串） */
  StartTime?: string
  /** 生效结束时间（ISO 字符串） */
  EndTime?: string
  /** 启用状态：1启用，0禁用 */
  EnableStatus?: number
  /** 激活状态：1激活，0未激活 */
  ActivationStatus?: number
  /** 父级协议ID（子协议场景） */
  ParentAgreementId?: string
  /** 协议编码（仅展示） */
  AgreementCode?: string
  /** 创建时间（仅展示） */
  CreationTime?: string
  /** 已绑定的收款码ID集合（仅展示与辅助绑定） */
  CodeIds?: string[]
}

export interface DividedAgreementListItem {
  Id?: string
  AgreementCode?: string
  AgreementName?: string
  CreationTime?: string
  IsDeleted?: boolean
  EnableStatus?: number
  ActivationStatus?: number
  ParentAgreementId?: string | null
}

/**
 * 类级注释：用户相关分账协议查询请求
 */
export interface UserRelatedDividedAgreementsRequest {
  /** 是否包含“参与者”维度 */
  IncludeParticipation: boolean
  /** 是否包含“创建者”维度 */
  IncludeOwned: boolean
  /** 商户ID（可选过滤） */
  MerchantId?: string
  /** 启用状态过滤：-1 不过滤，1启用，0禁用 */
  EnableStatus?: number
  /** 激活状态过滤：-1 不过滤，1激活，0未激活 */
  ActivationStatus?: number
  /** 仅展示子协议 */
  OnlySubAgreements?: boolean
  /** 仅展示我在明细中且未绑定子协议的明细所属协议 */
  OnlyMyDetailsWithoutSubAgreement?: boolean
  /** 页码（默认1） */
  Page?: number
  /** 每页数量（默认10） */
  Limit?: number
  /** 指定用户ID（默认当前登录用户） */
  UserId?: string
}

/**
 * 类级注释：用户相关分账协议列表项
 */
export interface UserRelatedAgreementItem {
  /** 协议ID */
  Id?: string
  /** 协议名称 */
  AgreementName?: string
  /** 协议编码 */
  AgreementCode?: string
  /** 商户ID */
  MerchantId?: string
  /** 启用状态 */
  EnableStatus?: number
  /** 激活状态 */
  ActivationStatus?: number
  /** 创建时间 */
  CreationTime?: string
  /** 父协议ID */
  ParentAgreementId?: string | null
  /** 我与该协议的关系：Owner/Participant */
  Relation?: string
  /** 我的分账比例（仅当为参与者时） */
  MyRatio?: number | null
  /** 生效开始时间 */
  StartTime?: string
  /** 生效结束时间 */
  EndTime?: string
}

/**
 * 类级注释：分账协议详情（参与者）类型
 */
export interface DividedAgreementDetailItem {
  /** 明细ID */
  Id?: string
  /** 协议ID */
  DividedAgreementId?: string
  /** 用户ID */
  UserId?: string
  /** 分账人手机号（用于确认场景） */
  UserPhone?: string
  /** 分账比例（0-1） */
  Ratio?: number
  /** 分账角色ID（可选） */
  UserRoleId?: string
  /** 是否主账户 */
  IsMasterAccount?: boolean
  /** 创建时间 */
  CreationTime?: string
}

/**
 * 类级注释：分账记录列表项（商户维度）
 */
export interface DividedRecordListItem {
  Id?: string
  RecordNo?: string
  OrderId?: string
  CodeId?: string
  DividedAgreementId?: string
  TotalDividedAmount?: number
  DividedDate?: string
  MerchantId?: string
  StoreId?: string
  CreationTime?: string
}

/**
 * 类级注释：批量绑定/设置分账协议下的收款码
 */
export interface SetDividedAgreementPaymentCodesRequest {
  /** 协议ID */
  DividedAgreementId: string
  /** 目标收款码ID集合（字段名需与后端 DTO 对齐） */
  PaymentCodeIds: string[]
}

/**
 * 类级注释：分账管理服务（静态方法）
 */
export class DividedService {
  /**
   * 函数级注释：获取分账协议列表
   * @param page 页码，默认 1
   * @param limit 每页数量，默认 10
   * @param key 模糊查询关键字（协议名称）
   * @param merchantId 商户ID（可选）
   * @param enableStatus 启用状态过滤（-1 不过滤）
   * @param activationStatus 激活状态过滤（-1 不过滤）
   * @returns ApiResult<PageResult<DividedAgreementListItem>> 返回分页数据
   * @throws 可能抛出网络请求异常
   */
  static async getDividedAgreementList(
    page: number = 1,
    limit: number = 10,
    key: string = '',
    merchantId: string = '',
    enableStatus: number = -1,
    activationStatus: number = -1
  ): Promise<ApiResult<PageResult<DividedAgreementListItem>>> {
    const resp = await http.get<ApiResult<PageResult<DividedAgreementListItem>>>(
      '/Divided/GetDividedAgreementList',
      { params: { page, limit, key, merchantId, enableStatus, activationStatus } }
    )
    return resp.data
  }

  /**
   * 函数级注释：获取单个分账协议详情（基础信息）
   * @param id 分账协议ID
   * @returns ApiResult<DividedAgreementRequest> 返回协议详细数据
   * @throws 可能抛出网络请求异常
   */
  static async getDividedAgreement(id: string): Promise<ApiResult<DividedAgreementRequest>> {
    const resp = await http.get<ApiResult<DividedAgreementRequest>>('/Divided/GetDividedAgreement', { params: { id } })
    return resp.data
  }

  /**
   * 函数级注释：新增分账协议
   * @param data 分账协议请求体（名称、周期、起止时间、商户ID等）
   * @returns ApiResult<string | boolean> 返回结果或新建ID（视后端定义）
   * @throws 可能抛出网络请求异常
   */
  static async addDividedAgreement(data: DividedAgreementRequest): Promise<ApiResult<string | boolean>> {
    const resp = await http.post<ApiResult<string | boolean>>('/Divided/AddDividedAgreement', data)
    return resp.data
  }

  /**
   * 函数级注释：编辑分账协议
   * @param data 分账协议请求体，需包含 `Id`
   * @returns ApiResult<boolean> 操作是否成功
   * @throws 可能抛出网络请求异常
   */
  static async updateDividedAgreement(data: DividedAgreementRequest): Promise<ApiResult<boolean>> {
    const resp = await http.post<ApiResult<boolean>>('/Divided/UpdateDividedAgreement', data)
    return resp.data
  }

  /**
   * 函数级注释：删除（归档）分账协议
   * @param id 协议ID
   * @returns ApiResult<boolean> 操作是否成功
   * @throws 可能抛出网络请求异常
   */
  static async deleteDividedAgreement(id: string): Promise<ApiResult<boolean>> {
    const resp = await http.post<ApiResult<boolean>>('/Divided/DeleteDividedAgreement', { Id: id })
    return resp.data
  }

  /**
   * 函数级注释：获取分账协议详情（参与者）列表
   * @param dividedAgreementId 协议ID
   * @returns ApiResult<DividedAgreementDetailItem[]> 返回明细列表
   * @throws 可能抛出网络请求异常
   */
  static async getDividedAgreementDetailList(dividedAgreementId: string): Promise<ApiResult<DividedAgreementDetailItem[]>> {
    const resp = await http.get<ApiResult<DividedAgreementDetailItem[]>>('/Divided/GetDividedAgreementDetailList', { params: { dividedAgreementId } })
    return resp.data
  }

  /**
   * 函数级注释：新增分账协议详情（参与者）
   * @param data 详情请求体：`DividedAgreementId, Ratio, UserId, UserRoleId?`
   * @returns ApiResult<boolean> 操作是否成功
   * @throws 可能抛出网络请求异常
   */
  static async addDividedAgreementDetail(data: Required<Pick<DividedAgreementDetailItem, 'DividedAgreementId' | 'Ratio' | 'UserId'>> & Pick<DividedAgreementDetailItem, 'UserRoleId'>): Promise<ApiResult<boolean>> {
    const resp = await http.post<ApiResult<boolean>>('/Divided/AddDividedAgreementDetail', data)
    return resp.data
  }

  /**
   * 函数级注释：编辑分账协议详情
   * @param data 详情请求体：需包含 `Id, Ratio, UserId`
   * @returns ApiResult<boolean> 操作是否成功
   * @throws 可能抛出网络请求异常
   */
  static async updateDividedAgreementDetail(data: Required<Pick<DividedAgreementDetailItem, 'Id' | 'Ratio' | 'UserId'>>): Promise<ApiResult<boolean>> {
    const resp = await http.post<ApiResult<boolean>>('/Divided/UpdateDividedAgreementDetail', data)
    return resp.data
  }

  /**
   * 函数级注释：批量编辑分账协议详情
   * @param list 详情请求体数组：`Id, Ratio, UserId`
   * @returns ApiResult<boolean> 操作是否成功
   * @throws 可能抛出网络请求异常
   */
  static async updateDividedAgreementDetails(list: Array<Required<Pick<DividedAgreementDetailItem, 'Id' | 'Ratio' | 'UserId'>>>): Promise<ApiResult<boolean>> {
    const resp = await http.post<ApiResult<boolean>>('/Divided/UpdateDividedAgreementDetails', list)
    return resp.data
  }

  /**
   * 函数级注释：删除分账协议详情（参与者）
   * @param ids 明细ID集合
   * @returns ApiResult<boolean> 操作是否成功
   * @throws 可能抛出网络请求异常；删除主账户将失败（由后端校验）
   */
  static async deleteDividedAgreementDetail(ids: string[]): Promise<ApiResult<boolean>> {
    const resp = await http.post<ApiResult<boolean>>('/Divided/DeleteDividedAgreementDetail', { Ids: ids })
    return resp.data
  }

  /**
   * 函数级注释：确认分账协议详情（参与者）
   * @param id 明细ID
   * @param phone 分账人手机号
   * @returns ApiResult<boolean> 操作是否成功
   * @throws 可能抛出网络请求异常
   */
  static async confirmDividedAgreementDetail(id: string, phone: string): Promise<ApiResult<boolean>> {
    const resp = await http.get<ApiResult<boolean>>('/Divided/ConfirmDividedAgreementDetail', { params: { id, phone } })
    return resp.data
  }

  /**
   * 函数级注释：设置分账协议下的收款码集合
   * @param data 请求体：`DividedAgreementId, PaymentCodeIds[]`
   * @returns ApiResult<boolean> 操作是否成功
   * @throws 可能抛出网络请求异常
   */
  static async setDividedAgreementPaymentCodes(data: SetDividedAgreementPaymentCodesRequest): Promise<ApiResult<boolean>> {
    const resp = await http.post<ApiResult<boolean>>('/Divided/SetDividedAgreementPaymentCodes', data)
    return resp.data
  }

  /**
   * 函数级注释：查询与当前用户（或指定用户）相关的分账协议列表
   * @param dto 查询请求体：参与者/创建者开关，状态过滤，分页等
   * @returns ApiResult<PageResult<UserRelatedAgreementItem>> 返回分页数据
   * @throws 可能抛出网络请求异常
   */
  static async getUserRelatedDividedAgreements(dto: UserRelatedDividedAgreementsRequest): Promise<ApiResult<PageResult<UserRelatedAgreementItem>>> {
    const resp = await http.get<ApiResult<PageResult<UserRelatedAgreementItem>>>('/Divided/GetUserRelatedDividedAgreements', { params: dto })
    return resp.data
  }

  /**
   * 函数级注释：手动新增分账记录
   * @returns ApiResult<boolean> 操作是否成功
   */
  static async addDividedRecord(): Promise<ApiResult<boolean>> {
    const resp = await http.get<ApiResult<boolean>>('/Divided/AddDividedRecord')
    return resp.data
  }

  /**
   * 函数级注释：手动分账结算
   * @param dividedTime 目标结算时间（Date 或 ISO 字符串）
   * @returns ApiResult<boolean> 操作是否成功
   */
  static async updateDividedRecord(dividedTime: string | Date): Promise<ApiResult<boolean>> {
    const resp = await http.get<ApiResult<boolean>>('/Divided/UpdateDividedRecord', { params: { dividedTime } })
    return resp.data
  }

  /**
   * 函数级注释：手动执行定时任务（结算、分账、分账结算）
   * @param dateTime 目标执行时间
   * @returns ApiResult<boolean> 操作是否成功
   */
  static async executeSettlementTask(dateTime: string | Date): Promise<ApiResult<boolean>> {
    const resp = await http.get<ApiResult<boolean>>('/Divided/ExecuteSettlementTask', { params: { dateTime } })
    return resp.data
  }

  /**
   * 函数级注释：获取分账记录报表
   * @param beginTime 开始时间
   * @param endTime 结束时间
   * @param merchantId 商户ID（传值时返回商户维度报表）
   * @returns ApiResult<any> 返回报表数据结构（由后端聚合定义）
   */
  static async getDividedRecordReport(beginTime: string | Date, endTime: string | Date, merchantId: string = ''): Promise<ApiResult<any>> {
    const resp = await http.get<ApiResult<any>>('/Divided/GetDividedRecordReport', { params: { beginTime, endTime, merchantId } })
    return resp.data
  }

  /**
   * 函数级注释：获取用户分账记录列表
   * @param beginTime 开始时间
   * @param endTime 结束时间
   * @param page 页码
   * @param limit 每页数量
   * @returns ApiResult<PageResult<any>> 返回分页数据
   */
  static async getUserDividedRecordList(beginTime: string | Date, endTime: string | Date, page: number = 1, limit: number = 10): Promise<ApiResult<PageResult<any>>> {
    const resp = await http.get<ApiResult<PageResult<any>>>('/Divided/GetDividedRecordList', { params: { beginTime, endTime, page, limit } })
    return resp.data
  }

  /**
   * 函数级注释：获取商户分账记录列表
   * @param dividedDate 分账日期（年/月/日）
   * @param page 页码
   * @param limit 每页数量
   * @param merchantId 商户ID
   * @param dividedAgreementId 分账协议ID
   * @param codeId 收款码ID
   * @returns ApiResult<PageResult<DividedRecordListItem>> 返回分页数据
   */
  static async getMerchantDividedRecordList(dividedDate: string | Date, page: number = 1, limit: number = 10, merchantId: string = '', dividedAgreementId: string = '', codeId: string = ''): Promise<ApiResult<PageResult<DividedRecordListItem>>> {
    const resp = await http.get<ApiResult<PageResult<DividedRecordListItem>>>('/Divided/GetMerchantDividedRecordList', { params: { dividedDate, page, limit, merchantId, dividedAgreementId, codeId } })
    return resp.data
  }

  /**
   * 函数级注释：获取用户分账记录详情树
   * @param dividedRecordId 分账记录ID
   * @returns ApiResult<any> 树状数据
   */
  static async getDividedRecordTreeForUser(dividedRecordId: string): Promise<ApiResult<any>> {
    const resp = await http.get<ApiResult<any>>('/Divided/GetDividedRecordTreeForUser', { params: { dividedRecordId } })
    return resp.data
  }

  /**
   * 函数级注释：获取完整分账树（基于静态快照比例）
   * @param orderId 订单ID（可选）
   * @param dividedRecordId 分账记录ID（可选）
   * @returns ApiResult<any> 树状数据
   */
  static async getDividedRecordFullTreeByOrderId(orderId?: string, dividedRecordId?: string): Promise<ApiResult<any>> {
    const resp = await http.get<ApiResult<any>>('/Divided/GetDividedRecordFullTreeByOrderId', { params: { orderId, dividedRecordId } })
    return resp.data
  }

  /**
   * 函数级注释：获取分账记录根层详情
   * @param dividedRecordId 分账记录ID
   * @returns ApiResult<any> 根层详情
   */
  static async getDividedRecordRootLayer(dividedRecordId: string): Promise<ApiResult<any>> {
    const resp = await http.get<ApiResult<any>>('/Divided/GetDividedRecordRootLayer', { params: { dividedRecordId } })
    return resp.data
  }

  /**
   * 函数级注释：获取分账记录详情列表
   * @param dividedRecordId 分账记录ID
   * @returns ApiResult<any[]> 详情列表
   */
  static async getDividedRecordDetailList(dividedRecordId: string): Promise<ApiResult<any[]>> {
    const resp = await http.get<ApiResult<any[]>>('/Divided/GetDividedRecordDetailList', { params: { dividedRecordId } })
    return resp.data
  }
}
